home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Linux Cubed Series 8: LINUX Games
/
Linux Cubed Series 8 - LINUX Games.iso
/
games
/
muds
/
lpmud312.tar
/
lpmud312
/
otable.c
< prev
next >
Wrap
C/C++ Source or Header
|
1991-10-31
|
4KB
|
185 lines
#include <stdio.h>
#include <string.h>
#include "lint.h"
#include "config.h"
#include "interpret.h"
#include "object.h"
/*
* Object name hash table. Object names are unique, so no special
* problems - like stralloc.c. For non-unique hashed names, we need
* a better package (if we want to be able to get at them all) - we
* cant move them to the head of the hash chain, for example.
*
* Note: if you change an object name, you must remove it and reenter it.
*/
char * xalloc();
/*
* hash table - list of pointers to heads of object chains.
* Each object in chain has a pointer, next_hash, to the next object.
* OTABLE_SIZE is in config.h, and should be a prime, probably between
* 100 and 1000. You can have a quite small table and still get very good
* performance! Our database is 8Meg; we use about 500.
*/
static struct object ** obj_table = 0;
static void init_otable()
{
int x;
obj_table = (struct object **)
xalloc(sizeof(struct object *) * OTABLE_SIZE);
for (x=0; x<OTABLE_SIZE; x++)
obj_table[x] = 0;
}
/*
* Object hash function, ripped off from stralloc.c.
*/
static int ObjHash(s)
char * s;
{
if (!obj_table)
init_otable();
return hashstr(s, 100, OTABLE_SIZE);
}
/*
* Looks for obj in table, moves it to head.
*/
static int obj_searches = 0, obj_probes = 0, objs_found = 0;
static struct object * find_obj_n(s)
char * s;
{
struct object * curr, *prev;
int h = ObjHash(s);
curr = obj_table[h];
prev = 0;
obj_searches++;
while (curr) {
obj_probes++;
if (!strcmp(curr->name, s)) { /* found it */
if (prev) { /* not at head of list */
prev->next_hash = curr->next_hash;
curr->next_hash = obj_table[h];
obj_table[h] = curr;
}
objs_found++;
return(curr); /* pointer to object */
}
prev = curr;
curr = curr->next_hash;
}
return(0); /* not found */
}
/*
* Add an object to the table - can't have duplicate names.
*/
static int objs_in_table = 0;
void enter_object_hash(ob)
struct object * ob;
{
struct object * s;
int h = ObjHash(ob->name);
s = find_obj_n(ob->name);
if (s) {
if (s != ob)
fatal("Duplicate object \"%s\" in object hash table",
ob->name);
else
fatal("Entering object \"%s\" twice in object table",
ob->name);
}
if (ob->next_hash)
fatal("Object \"%s\" not found in object table but next link not null",
ob->name);
ob->next_hash = obj_table[h];
obj_table[h] = ob;
objs_in_table++;
return;
}
/*
* Remove an object from the table - generally called when it
* is removed from the next_all list - i.e. in destruct.
*/
void remove_object_hash(ob)
struct object *ob;
{
struct object * s;
int h = ObjHash(ob->name);
s = find_obj_n(ob->name);
if (s != ob)
fatal("Remove object \"%s\": found a different object!",
ob->name);
obj_table[h] = ob->next_hash;
ob->next_hash = 0;
objs_in_table--;
return;
}
/*
* Lookup an object in the hash table; if it isn't there, return null.
* This is only different to find_object_n in that it collects different
* stats; more finds are actually done than the user ever asks for.
*/
static int user_obj_lookups = 0, user_obj_found = 0;
struct object * lookup_object_hash(s)
char * s;
{
struct object * ob = find_obj_n(s);
user_obj_lookups++;
if (ob) user_obj_found++;
return(ob);
}
/*
* Print stats, returns the total size of the object table. All objects
* are in table, so their size is included as well.
*/
static char sbuf[100];
int show_otable_status(verbose)
int verbose;
{
if (verbose) {
add_message("\nObject name hash table status:\n");
add_message("------------------------------\n");
sprintf(sbuf, "%.2f", objs_in_table / (float) OTABLE_SIZE);
add_message("Average hash chain length %s\n", sbuf);
sprintf(sbuf, "%.2f", (float)obj_probes / obj_searches);
add_message("Searches/average search length %d (%s)\n",
obj_searches, sbuf);
add_message("External lookups succeeded (succeed) %d (%d)\n",
user_obj_lookups, user_obj_found);
}
add_message("hash table overhead\t\t\t %8d\n",
OTABLE_SIZE * sizeof(struct object *));
return (OTABLE_SIZE * sizeof(struct object *) +
objs_in_table * sizeof(struct object));
}